home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 011 / misc.cq / misc.c
Encoding:
C/C++ Source or Header  |  1984-12-17  |  27.1 KB  |  957 lines
  1. #define F10 68
  2. #include "stdio.h"
  3. #include "b:header.c"
  4.  
  5. clrstf()                        /* clear s/f line pointers */
  6.     {
  7.     extern char *sfl1[], *sfl2[], *sfl3[], blnk9[], blnk16[],
  8.         constat[], fctkys[], discon[], conn[], hngup[], cparams[],
  9.         partmp[];
  10.     extern int connect, directry;
  11.     int i;
  12.     *(sfl1 + 1) = blnk16;
  13.     if ((modstat() & 0x80) == 0)
  14.         {
  15.         connect = 0;
  16.         *(sfl2) = discon;
  17.         *(sfl3) = blnk16;
  18.         if (directry)
  19.             {                   /* restore parameters */
  20.             directry = 0;
  21.             for (i = 0; i < 49; i++) cparams[i] = partmp[i];
  22.             }
  23.         }
  24.     else{
  25.         connect = 1;
  26.         *(sfl2) = conn;
  27.         *(sfl3) = hngup;
  28.         }
  29.     *(sfl2 + 1) = blnk16;
  30.     *(sfl3 + 1) = blnk16;
  31.     for (i = 2; i < 7; i++)
  32.         {
  33.         *(sfl2 + i) = blnk9;
  34.         *(sfl3 + i) = blnk9;
  35.         }
  36.     }
  37.  
  38. getkey()                /* get key from keyboard */
  39.     {
  40.     extern int uomode;
  41.     int c;
  42.     if (uomode) return(1);
  43.     printc((c = getkee()));
  44.     return(c);
  45.     }
  46.  
  47. entrsel(line, col)      /* put ENTER SELECTION on line,col */
  48.     int line, col;
  49.     {
  50.     extern char ensel[];
  51.     poscur(line, col);
  52.     printxt(ensel);
  53.     }
  54.  
  55. poscur(row, col)        /* cursor positioning routine */
  56.     int row, col;
  57.     {
  58.     struct regval srv, rrv;
  59.     srv.bx = 0;
  60.     srv.ax = 0x0200;
  61.     srv.dx = ((row - 1) << 8) + (col - 1);
  62.     sysint(16, &srv, &rrv);
  63.     }
  64.  
  65. clrwndw(r1, c1, r2, c2)         /* clear window r1,c1 to r2,c2 */
  66.     int r1, c1, r2, c2;
  67.     {
  68.     struct regval srv, rrv;
  69.     srv.cx = ((r1 - 1) << 8) + (c1 - 1);
  70.     srv.dx = ((r2 - 1) << 8) + (c2 - 1);
  71.     srv.bx = 0x0700;
  72.     srv.ax = 0x0600;
  73.     sysint(16, &srv, &rrv);
  74.     poscur(r1, c1);
  75.     }
  76.  
  77. initm()         /* initialize modem - do nothing for now */
  78.     {
  79.     return;
  80.     }
  81. clrscr()        /* clear screen */
  82.     {
  83.     struct regval srv, rrv;
  84.     srv.ax = 0x0600;
  85.     srv.cx = 0;
  86.     srv.dx = 0x184f;
  87.     srv.bx = 0x0700;
  88.     sysint(16, &srv, &rrv);
  89.     poscur(22, 1);
  90.     srv.bx = 0;
  91.     srv.cx = 79;
  92.     srv.ax = 0x0ACD;
  93.     sysint(16, &srv, &rrv);     /* draw line */
  94.     }
  95.  
  96. space(i)                /* space cursor over */
  97.     int i;
  98.     {
  99.     int row, col;
  100.     curpos(&row, &col);
  101.     poscur(row, col + i);
  102.     }
  103.  
  104. sfdispl()               /* display status/function lines */
  105.     {
  106.     extern char *sfl1[], *sfl2[], *sfl3[];
  107.     int i, row, col;
  108.     curpos(&row, &col);
  109.     poscur(23, 1);
  110.     for (i = 0; i < 3; i++) printxt(sfl1[i]);
  111.     putchar('\n');
  112.     for (i = 0; i < 7; i++) printxt(sfl2[i]);
  113.     putchar('\n');
  114.     for (i = 0; i < 7; i++) printxt(sfl3[i]);
  115.     poscur(row, col);
  116.     }
  117.  
  118. top(tspace, mspace, lines, text)
  119.     int tspace, mspace, lines;
  120.     char *text[];
  121.     {
  122.     int i;
  123.     extern int connect;
  124.     extern char *sfl2[], conn[], discon[];
  125.     clrwndw(1, 1, 21, 80);      /* clear upper screen */
  126.     space(tspace);              /* space over for title */
  127.     printxt(text[0]);           /* menu title */
  128.     for (i = 1; i < lines; i++)
  129.         {               /* output menu */
  130.         space(mspace);
  131.         printxt(text[i]);
  132.         }
  133.     clrstf();                   /* clear s/f line */
  134.     }
  135.  
  136. printxt(txtptr)         /* txtptr is pointer to text string. if in normal
  137.                            mode prints to screen; if in remote mode
  138.                            prints to comm port */
  139.     char *txtptr;
  140.     {
  141.     printf("%s", txtptr);       /* put remote test & call here later */
  142.     }
  143.  
  144. printc(c)
  145.     char c;
  146.     {
  147.     putchar(c);         /* put remote test and call here later */
  148.     }
  149.  
  150. getline(lineb, len)             /* getline from console */
  151.     char *lineb;
  152.     int len;
  153.     {
  154.     char key;
  155.     int k, i;
  156.     k = 0;
  157.     for (i = 0; i < len; i++) *(lineb + i) = 0;         /* clear lnbuf */
  158.     while ((key = toupper(getkee())) != CR)
  159.         {                       /* get console int5: */
  160.         if (key == ESC) return 0;
  161.         if ((key != BCKSP) && (k < (len-1)))
  162.             {*(lineb + (k++)) = key; printc(key); }
  163.         else if (key == BCKSP) { k--; printc(key); }
  164.         if (k < 0) k = 0;
  165.         }
  166.     *(lineb + k) = '\0';        /* mark end of string */
  167.     return (OK);
  168.     }
  169.  
  170.  
  171. char *ldfile(name, mode, bufsiz)        /* load file into buffer */
  172.     char *name, *mode;
  173.     int bufsiz;
  174.     {
  175.     extern char *edbuf;
  176.     char *ptr;
  177.     int *fd, i;
  178.     if ((fd = fopen(name, mode)) == 0) return 0;
  179.     i = 0;
  180.     zero(edbuf, bufsiz);
  181.     ptr = edbuf;
  182.     while(((*(ptr + i) = fgetc(fd)) != -1) && i < bufsiz) i++;
  183.     fclose(fd);
  184.     return(ptr);
  185.     }
  186.  
  187. svfile(name, mode, bufptr, bufsiz)      /* save a file */
  188.     char *name, *mode, *bufptr;
  189.     int bufsiz;
  190.     {
  191.     int *fd, i;
  192.     if ((fd = fopen(name, mode)) == 0) return 0;
  193.     i = 0;
  194.     while((fputc(*(bufptr + i), fd) != EOF) && (i < bufsiz)) i++;
  195.     fclose(fd);
  196.     if (i < bufsiz) return 0;
  197.     return (OK);
  198.     }
  199.  
  200.  
  201. match(xdir, xkw)        /* find best match on key word */
  202.     char *xdir, *xkw;
  203.     {
  204.     int i, value, valu[24], best, shift, m, n, pass;
  205.     char *tdir, *dir, *kw;
  206.     for (i = 0; i < 24; i++) valu[i] = 0;
  207.     for (shift = 0; shift < 2; shift++)         /* shift both directions */
  208.         {
  209.         for (i = 0; i < 24; i++)
  210.             {                           /* compare on all 24 entries */
  211.             tdir = xdir + (i * 128);    /* next entry */
  212.             if (*tdir == 0) continue;   /* skip if entry is null */
  213.             for (m = 0; m < 10; m++)
  214.                 {                       /* shift up to 10 char positions */
  215.                 pass = value = n = 0;
  216.                 if (shift == 0)
  217.                     {                   /* shifting right */
  218.                     dir = tdir + m;
  219.                     kw = xkw;
  220.                     }
  221.                 else{                   /* shifting left */
  222.                     dir = tdir;
  223.                     kw = xkw + m;
  224.                     }
  225.                 while ((*dir != 0) && (*kw != 0) && (pass < 20-m))
  226.                     {
  227.                     if ((*dir == *kw)&&(*dir!=' ')) n++;/* the test! */
  228.                     else n = 0;
  229.                     value += n*n;               /* bump value */
  230.                     dir++;
  231.                     kw++'Q                  pass++;
  232.                     }
  233.                 valu[i] += value;               /* accumulate values */
  234.                 if(n==pass && *dir==0 && *kw==0)
  235.                         {
  236.                         valu[i] += 20;          /* bonus */
  237.                         if (m == 0) valu[i] += 100;  /* extra bonus */
  238.                         }
  239.                 }
  240.             }
  241.         }
  242.     value = 0;
  243.     best = 0;
  244.     for (i = 0; i < 24; i++)
  245.         if (valu[i] > value)
  246.             {
  247.             value = valu[i];
  248.             best = i;
  249.             }
  250.     return (xdir + (best * 128));
  251.     }
  252.  
  253.  
  254. sort(bufptr, ellen, numel)              /* sort in alpha/num order */
  255.     char *bufptr;
  256.     int ellen, numel;
  257.     {
  258.     extern char *lnbuf;
  259.     int i, j, k;
  260.     char *tptr, *temp, *bottom;
  261.     zero(lnbuf, ellen+1);
  262.     temp = lnbuf;
  263.     tptr = bufptr;
  264.     for (k = 0; k < numel-1; k++)
  265.         {
  266.         for (j = 0; j < (numel-k-1); j++)
  267.             {
  268.             for (i = 0; i < ellen; i++)
  269.                 {
  270.                 if (*(tptr+i) > *(tptr+i+ellen))
  271.                     {
  272.                     movmem(tptr, temp, ellen);
  273.                     movmem(tptr+ellen, tptr, ellen);
  274.                     movmem(temp, tptr+ellen, ellen);
  275.                     break;
  276.                     }
  277.                 if (*(tptr+i) != *(tptr+i+ellen)) break;
  278.                 if (*(tptr+i) == 0) break;
  279.                 }
  280.             tptr += ellen;
  281.             }
  282.         tptr = bufptr;
  283.         }
  284.     }
  285.  
  286.  
  287.  
  288. displn(ptr)             /* display line on screen starting at beginning of
  289.                            line.  Cursor left at same position + 1 */
  290.     char *ptr;
  291.     {
  292.     char c;
  293.     extern char *start;
  294.     int brt, ul, row, col, i, j;
  295.     brt = ul = 0;
  296.     curpos(&row, &col);
  297.     while (*ptr < 3) ptr++;
  298.     c = *ptr;                   /* get actual character */
  299.     while(*(ptr-1) < 3)  ptr--; /* include attr. */
  300.     i = col;
  301.     while (fwrdtst(ptr))
  302.         {               /* while not at end of line */
  303.         if (*ptr == BRTCODE) brt = 1;
  304.         else if (*ptr == ULCODE) ul = 1;
  305.         else if (*ptr == TAB)
  306.             {
  307.             printxt("     ");
  308.             i += 5;
  309.             brt = ul = 0;
  310.             }
  311.         else{
  312.             printce(*ptr, brt, ul);
  313.             brt = ul = 0;
  314.             if (i > 78) i = 78;
  315.             poscur(row, ++i);
  316.             }
  317.         ptr++;
  318.         }
  319.     brt = ul = 0;
  320.     j = 0;
  321.     while ((i++) < 80 && (j++ < 5))     /* this is for DELETE function */
  322.         printc(' ');
  323.     if (col == 80) col--;
  324.     if (c =} TAB) poscur(row, col+5);
  325.     else poscur(row, col+1);
  326.     if (*ptr == CTLZ) return 0;
  327.     return(OK);
  328.     }
  329.  
  330. char *nxtlast(dir, ptr) /* if dir = 1, moves pointer
  331.                            forward 1 line else moves back 1 line */
  332.     int dir;
  333.     char *ptr;
  334.     {
  335.     extern char *start;
  336.     if (dir == NEXT)
  337.         {
  338.         while (fwrdtst(ptr)) ptr++;
  339.         if (*ptr == LF || *ptr == SLF) ptr++;
  340.         }
  341.     else{
  342.         if ((*ptr == LF || *ptr == SLF) && (ptr != start)) ptr--;
  343.         while ((*ptr != LF) && (ptr != start) && (*ptr != SLF)) ptr--;
  344.         if (ptr != start) ptr--;
  345.         else return(ptr);
  346.         while ((*ptr != LF) && (ptr != start) && (*ptr != SLF)) ptr--;
  347.         if (*ptr == LF || *ptr == SLF) ptr++;
  348.         }
  349.     return(ptr);
  350.     }
  351.  
  352. printce(c, b, u)        /* print character with attribute */
  353.     char c;
  354.     int b, u;
  355.     {
  356.     int row, col;
  357.     struct regval srv, rrv;
  358.     srv.ax = 0x0900 + c;
  359.     srv.bx = 7;         /* default - no attribute */
  360.     srv.cx = 1;
  361.     if (b == 1) srv.bx = 0x0F;
  362.     if (u == 1) srv.bx = srv.bx & 0x09;
  363.     sysint(16, &srv, &rrv);
  364.     }
  365.  
  366. getkee()                        /* used by editor - non-echoing */
  367.     {
  368.     long offset;
  369.     extern char *macbuf, *macptr, *sfl2[], *sfl3[], discon[], blnk16[],
  370.         source;
  371.     char c, *tptr, end;
  372.     extern int strtmac, defmac, usemac, lfunct, mtemp, blokvid, connect,
  373.         err;
  374.     int *fd, i, row, col;
  375.     end = 0xFF;
  376.     if (err) { drline(); err = 0; }
  377.     while(1)
  378.         {
  379.         if (usemac)
  380.             {
  381.             c = *(macptr++);
  382.             if (c != end)
  383.                 {
  384.                 if (*macptr == end) usemac = 0;
  385.                 return(c);
  386.                 }
  387.             usemac = 0;
  388.             }
  389.         if (lfunct)
  390.             {
  391.             lfunct = 0;
  392.             c = mtemp;
  393.             }
  394.         else c = bdos(7) & 0xFF;
  395.         if (c != 0)
  396.             {
  397.             if ((defmac) && (*macptr != end)) *(macptr++) = c;
  398.             return(c);
  399.             }
  400.         mtemp = bdos(7) & 0xFF;         /* it was a 0, get next kek */
  401.         if ((mtemp < 16) || (mtemp > 50))
  402.             {                           /* not alt-alpha */
  403.             if (mtemp == F10)
  404.                 {                       /* hang-up */
  405.                 connect = 0;
  406.                 modcon(0);
  407.                 *(sfl2) = discon;
  408.                 *(sfl3) = blnk16;
  409.                 sfdispl();
  410.                 return(bdos(7) & 0xFF);
  411.                 }
  412.             lfunct = 1;
  413.             if ((defmac) && (*macptr != end)) *(macptr++) = 0;
  414.             return(c);
  415.             }
  416.                         /* it is alt-alpha */
  417.         if (strtmac)
  418.             {                           /* start mac is active */
  419.             if (mtemp == *(macbuf + 1))
  420.                 {                       /* its the right code */
  421.                 defmac = 1;
  422.                 strtmac = 0;
  423.                 curpos(&row, &col);
  424.                 poscur(22, 55);         /* change message */
  425.                 printc(*macbuf);
  426.                 printxt(" KEY PROG IN PROCESS ");
  427.                 *(macbuf + 22) = source;
  428.                 poscur(row, col);
  429.                 continue;               /* get next key */
  430.                 }
  431.             }
  432.         if (!defmac)
  433.             {                   /* check to see if programmed key */
  434.             if ((fd = fopen("PROGKEYS.RVC", "rb")) != 0)
  435.                 {               /* a macro file does exist */
  436.                 fgetc(fd);      /* ignore alpha */
  437.                 offset = 127;
  438.                 for (i = 0; i < 26; i++)
  439.                     {
  440.                     if (fgetc(fd) == mtemp) break;      /* look for altcode */
  441.                     fseek(fd, offset, 1);
  442.                     }
  443.                 if (i != 26)
  444.                     {                   /* programmed key! */
  445.                     fseek(fd, -2L, 1);  /* back-up */
  446.                     fgets(macbuf, 128, fd);     /* get macro */
  447.                     if (source == *(macbuf + 22))
  448.                         {
  449.                         usemac = 1;
  450.                         macptr = macbuf + 23;
  451.                         }
  452.                     else { wrongscr(*(macbuf+22)); err = 1; }
  453.                     fclose(fd);
  454.                     continue;
  455.                     }
  456.                 fclose(fd);
  457.                 }
  458.             lfunct = 1;                 /* not programmed key */
  459.             return(0);
  460.             }
  461.                         /* defmac is active */
  462.         if (mtemp == *(macbuf + 1))
  463.             {                           /* terminate macro definition */
  464.             fd = fopen("PROGKEYS.RVC", "rwb");
  465.             offset = (*macbuf - 0x41) * 128;
  466.             fseek(fd, offset, 0);
  467.             *macptr = end;
  468.             macptr = macbuf;
  469.             for (i = 0; i < 128; i++)
  470.                 fputc(*(macptr++), fd);
  471.             fclose(fd);
  472.             defmac = 0;
  473.             drline();           /* clear message */
  474.             }
  475.         }
  476.     }
  477.  
  478. curpos(row, col)                /* 2e}urns row & col position of cursor */
  479.     int *row, *col;
  480.     {
  481.     struct regval srv, rrv;
  482.     srv.ax = 0x0300;
  483.     srv.bx = 0;
  484.     sysint(16, &srv, &rrv);
  485.     *row = (rrv.dx >> 8) +1;
  486.     *col = (rrv.dx & 0xFF) + 1;
  487.     }
  488.  
  489. opencl(type, ptr, bytes, count) /* type = 0; close buffer
  490.                                         = 1; open buffer
  491.                                    ptr = start of source address
  492.                                    bytes = # of bytes to open/close by
  493.                                    count = total # of bytes to move */
  494.     int type, bytes, count;
  495.     char *ptr;
  496.     {
  497.     if (type == 1)
  498.         movmem(ptr, (ptr + bytes), count+1);
  499.     else movmem(ptr, (ptr-bytes), count+1);
  500.     return;
  501.     }
  502.  
  503. scrolup(tline, bline)                   /* scroll edit window up 1 line */
  504.     int tline, bline;
  505.     {
  506.     struct regval srv, rrv;
  507.     srv.ax = 0x0601;
  508.     srv.cx = (tline-1) << 8;
  509.     srv.dx = ((bline-1) << 8) + 0x4F;
  510.     srv.bx = 0x0700;
  511.     sysint(16, &srv, &rrv);
  512.     }
  513.  
  514. char *lnend(ptr)                        /* finds end of line */
  515.     char *ptr;
  516.     {
  517.     while(fwrdtst(ptr)) ptr++;
  518.     return(ptr);
  519.     }
  520.  
  521. char *lnstrt(ptr)               /* finds start of line */
  522.     char *ptr;
  523.     {
  524.     extern char *start;
  525.     if (ptr == start) return(ptr);
  526.     if(*ptr == LF || *ptr == SLF) ptr--;
  527.     while((*ptr != LF) && (ptr != start) && (*ptr != SLF)) ptr--;
  528.     if (*ptr == LF || *ptr == SLF) ptr++;
  529.     return(ptr);
  530.     }
  531.  
  532. getattr()                       /* returns attribute at cur. pos. */
  533.     {
  534.     struct regval srv, rrv;
  535.     srv.ax = 0x0800;
  536.     srv.bx = 0;
  537.     sysint(16, &srv, &rrv);
  538.     return(rrv.ax >> 8);
  539.     }
  540.  
  541. dispscr(ptr)                    /* displays screen */
  542.     char *ptr;
  543.     {
  544.     int i;
  545.     i = 0;
  546.     while((i < 21) && (displn(ptr) == OK))
  547.         {
  548.         ptr = nxtlast(NEXT, ptr);
  549.         i++;
  550.         printc('\n');
  551.         }
  552.     return(i+1);                /* returns # of lines displayed */
  553.     }
  554.  
  555. scroldn(tline, bline)           /* scroll down 1 line */
  556.     int tline, bline;
  557.     {
  558.     struct regval srv, rrv;
  559.     srv.ax = 0x0701;
  560.     srv.cx = (tline-1) << 8;
  561.     srv.dx = ((bline-1) << 8) + 0x4F;
  562.     srv.bx = 0x0700;
  563.     sysint(16, &srv, &rrv);
  564.     }
  565.  
  566. attribut()              /* inserts attribute codes for new kbd input */
  567.     {
  568.     extern brtattr, ulattr;
  569.     extern char *fend, *bend, *mptr;
  570.     if(brtattr != 0)
  571.         {               /* insert bright code */
  572.         opencl(1, mptr, 1, (fend-mptr+1));
  573.         fend++;
  574.         *mptr = BRTCODE;
  575.         mptr++;
  576.         }
  577.     if (ulattr != 0)
  578.         {               /* insert underline code */
  579.         opencl(1, mptr, 1, (fend-mptr+1));
  580.         fend++;
  581.         *mptr = ULCODE;
  582.         mptr++;
  583.         }
  584.     if (fend >= bend) return 0;
  585.     return (OK);
  586.     }
  587.  
  588. zero(ptr, bytes)
  589.     char *ptr;
  590.     unsigned int bytes;
  591.     {
  592.     for ( ; bytes > 0; bytes--) *(ptr++) = 0;
  593.     }
  594.  
  595. bkuptst(ptr)            /* back-up test */
  596.     char *ptr;
  597.     {
  598.     extern char *start;
  599.     if ((ptr != start) && (*(ptr-1) != LF) && (*(ptr-1) != SLF))
  600.         return(1);
  601.     return(0);
  602.     }
  603.  
  604. fwrdtst(ptr)            /* forward test */
  605.     char *ptr;
  606.     {
  607.     if ((*ptr != LF) && (*ptr != CTLZ)
  608.         && (*ptr != SLF) && (*ptr != INSMARK))
  609.         return(1);
  610.     return(0);
  611.     }
  612.  
  613. instst()                /* insert mode test */
  614.     {
  615.     extern int insrt;
  616.     if (insrt == 1)
  617.         {
  618.         printc(7);
  619.         return(1);
  620.         }
  621.     return(0);
  622.     }
  623.  
  624. wrap(ptr)               /* word wrap - ptr points to start of line */
  625.     char *ptr;
  626.     {
  627.     int i;
  628.     char *tptr;
  629.     i = 1;
  630.     while(*ptr != LF && *ptr != CTLZ)
  631.         {
  632.         if (*ptr > 8) i++;
  633.         if (*ptr == SLF) *ptr = SPACE;
  634.         if (*ptr == TAB) i += 4;
  635.         if (i > 76)
  636.             {
  637.             tptr = ptr;
  638.             while((*tptr != SPACE) && (bkuptst(tptr))) tptr--;
  639.             if (*tptr != SPACE)
  640.                 {
  641.                 tptr = ptr;
  642.                 opencl(1, tptr, 1, (fend-tptr+1));
  643.                 fend++;
  644.                 }
  645.             *tptr = SLF;
  646.             i = 1;
  647.             ptr = tptr;
  648.             }
  649.         ptr++;
  650.         }
  651.     }
  652.  
  653. char lcntrl()                   /* RETURNS LINE CONTROL BYTE FOR UART */
  654.     {
  655.     extern char cparams[];
  656.     char x;
  657.     x = 0;
  658.     x = x + (cparams[0] - 0x30) - 5;            /* word length */
  659.     x = x + (((cparams[1] - 0x30) - 1) << 2);   /* stop bits */
  660.     x = x + ((cparams[2] - 0x30) << 3);         /* parity enable */
  661.     x = x + ((cparams[3] - 0x30) << 4);         /* parity sense */
  662.     return(x);
  663.     }
  664.  
  665. chkfile(fname)                  /* checks to see if file exists */
  666.     char *fname;
  667.     {
  668.     char *fcb;
  669.     fcb = makefcb(fname);
  670.     if (bdos(0x11, fcb) & 0xFF)
  671.         {
  672.         free(fcb);
  673.         return(OK);
  674.         }
  675.     clrwndw(17, 1, 21, 80);
  676.     space(10);
  677.     printxt("A file already exists by this name.  If you wish to cancel\n");
  678.     space(10);
  679.     printxt("this command press <ESC>.  If you wish to erase the existing\n");
  680.     space(10);
  681.     printxt("file and create a new one with the same name, press any other\n");
  682.     space(10);
  683.     printxt("key. ");
  684.     if (getkee() == ESC)
  685.         {
  686.         free(fcb);
  687.         return(0);
  688.         }
  689.     clrwndw(17, 1, 21, 80);
  690.     bdos(0x13, fcb);            /* erase file */
  691.     free(fcb);
  692.     return(OK);
  693.     }
  694.  
  695.  
  696. edfield(len, fptr)              /* edit field; len = field length */
  697.                                 /* fptr = pointer to start of field */
  698.     int len;
  699.     char *fptr;
  700.     {
  701.     int row, col, col1, insrt;
  702.     char *dptr, *tptr, c;
  703.     curpos(&row, &col);
  704.     col1 = col;                 /* left column */
  705.     dptr = tptr = fptr;
  706.     while (*dptr != '\0') printc(*dptr++);
  707.     poscur(row, col);
  708.     insrt = 0;
  709.     while ((c = toupper(getkee())) != CR)
  710.                 {
  711.                 curpos(&row, &col);
  712.                 if (c =} 0)
  713.                     {           /* edit key */
  714.                     c = getkee();
  715.                     if (c == RTAROW)
  716.                         {
  717.                         col++;
  718.                         if (col >= col1 + len - 1) col--;
  719.                         else{
  720.                             tptr++;
  721.                             poscur(row, col);
  722.                             }
  723.                         }
  724.                     else if (c == LTAROW)
  725.                         {
  726.                         col--;
  727.                         if (col < col1) col++;
  728.                         else{
  729.                             tptr--;
  730.                             poscur(row, col);
  731.                             }
  732.                         }
  733.                     else if (c == DELETE)
  734.                         {
  735.                         dptr = tptr;
  736.                         while (*dptr++ != '\0') *(dptr-1) = *dptr;
  737.                         dptr = tptr;
  738.                         while (*dptr != '\0') pr{ntc(*dptr++);
  739.                         printc(' ');
  740.                         poscur(row, col);
  741.                         }
  742.                     else if (c == INSERT) insrt = !insrt;
  743.                     }
  744.                 else if (c == BCKSP)
  745.                     {
  746.                     col--;
  747.                     if (col < col1) col++;
  748.                     else{
  749.                         tptr--;
  750.                         poscur(row, col);
  751.                         }
  752.                     }
  753.                 else if (insrt == 1)
  754.                     {
  755.                     dptr = fptr + len -2;
  756.                     while (dptr-- != tptr) *(dptr+1) = *dptr;
  757.                     *tptr = c;
  758.                     dptr = tptr;
  759.                     while (*dptr != '\0') printc(*dptr++);
  760.                     if (tptr != (fptr + len - 2))
  761.                         {
  762.                         tptr++;
  763.                         col++;
  764.                         }
  765.                     poscur(row, col);
  766.                     }
  767.                 else{
  768.                     if (tptr == fptr + len -2)
  769.                         {
  770.                         *tptr = c;
  771.                         printc(c);
  772.                         poscur(row, col);
  773.                         }
  774.                     else{
  775.                         *tptr++ = c;
  776.                         printc(c);
  777.                         }
  778.                     }
  779.                 }
  780.     }
  781.  
  782.  
  783. wrongscr(c)             /* wrong source messages for macros */
  784.     char c;
  785.     {
  786.     int row, col;
  787.     static char *wsrctxt[] = {
  788.         "FROM MAIN MENU",                       /* 0 */
  789.         "FROM TERMINAL CONNECTION MENU",        /* 1 */
  790.         "FROM DIAL SEQUENCE MENU",              /* 2 */
  791.         "IN TERMINAL EMULATION MODE",           /* 3 */
  792.         "FROM FILE MAINTENANCE MENU",           /* 4 */
  793.         "WHEN SPECIFYING A FILE NAME",          /* 5 */
  794.         "FROM ANSWER TELEPHONE MENU",           /* 6 */
  795.         "FROM HELP MENU",                       /* 7 */
  796.         "FROM REMOTE CONSOLE MENU",             /* 8 */
  797.         "FROM TELEPHONE DIRECTORY MENU",        /* 9 */
  798.         "WHEN ADDING A TEL. DIR. ENTRY",        /* 10 */
  799.         "WHEN EDITING A FILE",                  /* 11 */
  800.         "WHEN SPECIFYING A KEYWORD",            /* 12 */
  801.         "WHEN SPECIFYING A TELEPHONE NO.",      /* 13 */
  802.         "WHEN SPECIFYING A LOG-ON SEQ.",        /* 14 */
  803.         "WHEN SPECIFYING A FORMAT FIELD",       /* 15 */
  804.         "FROM THE OPTIONS MENU",                /* 16 */
  805.         "WHEN SPECIFYING OPTIONS",              /* 17 */
  806.         "FROM PROGRAM KEYS MENU"  };            /* 18 */
  807.     curpos(&row, &col);
  808.     poscur(22, 5);
  809.     printxt("THIS PROGRAMMED KEY MAY ONLY BE INITIATED ");
  810.     printxt(wsrctxt[c]);
  811.     poscur(row, col);
  812.     }
  813.  
  814.  
  815. drline()                /* draw line */
  816.     {
  817.     struct regval srv, rrv;
  818.     int row, col;
  819.     curpos(&row, &col);
  820.     posc](22, 1);
  821.     srv.bx = 0;
  822.     srv.cx = 79;
  823.     srv.ax = 0x0ACD;
  824.     sysint(16, &srv, &rrv);
  825.     poscur(row, col);
  826.     }
  827.  
  828.  
  829. vde(n)                          /* VIEW DIRECTORY ENTRIES */
  830.     int n;                      /* 0 = keywords; 1 = all fields */
  831.     {
  832.     extern char *ppaktc, *ntdeoyd, *labels[], *edbuf, *teledir;
  833.     char *dirptr, *tptr, *start, *ldfile();
  834.     extern int fldlen[];
  835.     int i, j, k, row, col;
  836.     if (n == 0) i = 13;
  837.     else
  838.         {
  839.         i = 1;
  840.         clrstf();
  841.         sfdispl();
  842.         }
  843.     clrwndw(i, 1, 21, 80);      /* clear lower display */
  844.     if (ldst(edbuf, teledir, 24, 0) == 0)
  845.         {
  846.         if (n == 0) return;
  847.         poscur(10,á5);
  848.         printxt(ntdeoyd);       /* no telephone directory */
  849.         space(10);
  850.         printxt(ppaktc);    á   /* press any key to continue */
  851.         getkey();
  852.         return(RDISMEN);
  853.         }
  854.     dirptr = edbuf;
  855.     i = k = 0;
  856.     while(*dirptr == 0)
  857.         {
  858.         k++;
  859.         dirptr += 128;
  860.         if (k == 24) break;
  861.         }
  862.     if (n == 0)
  863.       {
  864.     row = 15;
  865.     col = 8;
  866.     space(7);
  867.     printxt("Telephone Directory Keywords:");
  868.     for ( ; k < 24; k++)
  869.         {
  870.         poscur(row, col);
  871.         j = 0;
  872.         while((*(dirptr + j) != 0) && (j < 15))
  873.                 printc(*(dirptr + (j++)));
  874.         if (++row == 21)
  875.             {
  876.             row = 15;
  877.             col += 17;
  878.             }
  879.         dirptr += 128;
  880.         }
  881.      }
  882.     else{
  883.         j = 0;
  884.         for ( ; k < 24; k++)
  885.             {
  886.             tptr = dirptr;
  887.             for (i = 0; i < 4; i++)
  888.                 {
  889.                 space(10);
  890.                 printxt(labels[i]);
  891.                 while(*tptr != '\0') printc(*tptr++);
  892.                 printc('\n');
  893.                 dirptr += fldlen[i];
  894.                 tptr = dirptr;
  895.                 }
  896.             printc('\n');
  897.             if ((++j == 4) && (k != 23))
  898.                 {
  899.                 j = 0;
  900.                 space(20);
  901.                 printxt(ppaktc);
  902.                 if (getkee() == ESC) return(RDISMEN);
  903.                 clrwndw(1, 1, 21, 80);
  904.                 }
  905.             }
  906.         space(20);
  907.         printxt(ppaktc);
  908.         getkey();
  909.         }
  910.     return (RDISMEN);
  911.     }
  912.  
  913. ldst(ptr, file, recs, ls)               /* fast load/store file routine */
  914.     char *ptr, *file;                   /* ls, 0 = load; 1 = store */
  915.     int recs, ls;
  916.      {
  917.     char *fcb;
  918.     struct segval sval;
  919.     struct regval srv, rrv;
  920.     if ((fcb = makefcb(file)) == 0) return 0;
  921.     if (bdos(0x0F, fcb) & 0xFF)
  922.         {
  923.         free(fcb);
  924.         return 0;
  925.         }
  926.     bdos(0x1A, ptr);            /* set dta */
  927.     bdos(0x24, fcb);            /* set random record field */
  928.     segread(&sval);             /* get segment values */
  929.     if (ls == 0) srv.ax = 0x2700;
  930.     else srv.ax = 0x2800;
  931.     srv.xds = sval.ds;          /* set data seg */
  932.     srv.dx = fcb;
  933.     srv.cx = recs;
  934.     sysint(0x21, &srv, &rrv);
  935.     if (ls == 1) bdos(0x10, fcb);
  936.     free(fcb);
  937.     return(OK);
  938.     }
  939.  
  940.  
  941. char *exact(entry, dir)         /* looks for exact directory match */
  942.     char *entry, *dir;
  943.     {
  944.     int i, j;
  945.     for (j = 0; j < 24; j++)
  946.         {
  947.         for (i = 0; i < 20; i++)
  948.             {
  949.             if (*(entry+i) != *(dir+i)) break;
  950.             }
  951.         if (i == 20) return (dir);      /* exact match */
  952.         dir += 128;
  953.         }
  954.     return (0);
  955.     }
  956.  
  957.